/*河南星辰软件科技有限公司
@copyright Copyright (c) 2010~2022 All rights reserved.
*/
package cn.javaxc.mes.action.product;
import java.io.*;
import java.util.*;
import java.sql.*;
import cn.javaxc.model.base.SQL;
import cn.javaxc.model.base.SQLList;
import cn.javaxc.model.base.SQLMap;
import cn.javaxc.model.base.SQLParam;
import cn.javaxc.model.page.BatisPage;
import cn.javaxc.mvcwork.controller.web.TreeBean;
import cn.javaxc.mvcwork.util.common.CommonUtil;
import cn.javaxc.mvcwork.util.common.MapListUtil;
import cn.javaxc.mvcwork.util.helper.FrameHelper;
import cn.javaxc.mvcwork.util.helper.TreeTableHelper;
import org.springframework.beans.factory.annotation.Autowired;
import cn.javaxc.mvcwork.controller.GenericValidator;
import cn.javaxc.mvcwork.controller.AppUtils;
import cn.javaxc.system.action.base.BaseAction;
import cn.javaxc.talent.util.data.*;
import cn.javaxc.mes.mapper.product.TechnologyMapper;
public class TechnologyAction extends BaseAction
{
    @Autowired(required=false)
	private TechnologyMapper mapper;
    /**
    统计图
    */
    
    public Map technologyStatistical() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        result.put("s_search", pagination.getSearchParas());
        
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        
        SQLList<SQLMap> s_category=mapper.s_category(params);
        result.put("s_category", s_category);
        
        
        SQLList<SQLMap> tech_list=mapper.tech_list(params);
        result.put("tech_list", tech_list);
        
        return result;
    }
    /**
    检测范围列表
    */
    
    public Map cartogramTechnology() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_category=mapper.s_category(params);
        SQLMap s_category_emt=s_category.getExistfirst();
        result.put("s_category", s_category_emt);
        
        return result;
    }
    /**
    生产步骤表
    */
    
    public Map productTechStep() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        SQLList<SQLMap> s_next=mapper.s_next(params);
        result.put("s_next", s_next);
        
        
        
        
        
        
        
        
        
        
        
        return result;
    }
    /**
    配置阶段
    */
    
    public Map productTechStage() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_action=mapper.s_action(params);
        result.put("s_action", s_action);
        
        
        SQLList<SQLMap> s_next=mapper.s_next(params);
        result.put("s_next", s_next);
        
        
        
        return result;
    }
    /**
    方案项目列表
    */
    
    public Map programItems() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        
        
        
        
        SQLList<SQLMap> s_produce=mapper.s_produce(params);
        result.put("s_produce", s_produce);
        
        
        
        return result;
    }
    /**
    检测项目流程图
    */
    
    public Map projectFlowChart() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        SQLList<SQLMap> skips=mapper.skips(params);
        result.put("skips", skips);
        
        return result;
    }
    /**
    检测模板
    */
    
    public Map detectionTemplate() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        
        
        
        
        SQLList<SQLMap> l_record_work=mapper.l_record_work(params);
        result.put("l_record_work", l_record_work);
        
        
        
        return result;
    }
    /**
    流程图下一步
    */
    
    public Map chartNextStep() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        
        SQLList<SQLMap> s_skip=mapper.s_skip(params);
        result.put("s_skip", s_skip);
        
        return result;
    }
    /**
    关联下一步
    */
    
    public Map relevantNextStep1() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params,pagination);
        s_pro.setPagedListInfo(pagination);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    检测方案列表
    */
    
    public Map testPlanList() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_scheme=mapper.s_scheme(params);
        result.put("s_scheme", s_scheme);
        
        return result;
    }
    /**
    修改检测方案
    */
    
    public Map upTestPlan1() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_scheme=mapper.t_scheme(params);
        SQLMap t_scheme_emt=t_scheme.getExistfirst();
        result.put("t_scheme", t_scheme_emt);
        
        return result;
    }
    /**
    基本情况
    */
    
    public Map planDet() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_category=mapper.t_category(params);
        SQLMap t_category_emt=t_category.getExistfirst();
        result.put("t_category", t_category_emt);
        
        return result;
    }
    /**
    适用产品
    */
    
    public Map applicableProductPlan() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_tech_produce=mapper.s_tech_produce(params,pagination);
        s_tech_produce.setPagedListInfo(pagination);
        result.put("s_tech_produce", s_tech_produce);
        
        return result;
    }
    /**
    选择适用产品
    */
    
    public Map choiceProductPlan() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        
        params.def("CMID1",-1);
        SQLList<SQLMap> s_classid=mapper.s_classid(params);
        result.put("s_classid", s_classid);
        
        
        SQLList<SQLMap> p_produce=mapper.p_produce(params,pagination);
        p_produce.setPagedListInfo(pagination);
        p_produce.setSelectNone("produce备注");
        result.put("p_produce", p_produce);
        
        return result;
    }
    /**
    检测方案修改
    */
    
    public Map upTestPlan() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_category=mapper.t_category(params);
        SQLMap t_category_emt=t_category.getExistfirst();
        result.put("t_category", t_category_emt);
        
        return result;
    }
    /**
    检测标准
    */
    
    public Map testingCriteria() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_tech=mapper.t_tech(params);
        result.put("t_tech", t_tech);
        
        return result;
    }
    /**
    修改检测标准
    */
    
    public Map upTestingCriteria() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_tech=mapper.t_tech(params);
        SQLMap t_tech_emt=t_tech.getExistfirst();
        result.put("t_tech", t_tech_emt);
        
        return result;
    }
    /**
    检测项目
    */
    
    public Map testingItemsPlan() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> plan_produce=mapper.plan_produce(params,pagination);
        plan_produce.setPagedListInfo(pagination);
        result.put("plan_produce", plan_produce);
        
        return result;
    }
    /**
    选择工序
    */
    
    public Map selectionProcessPlan() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> pro_produce=mapper.pro_produce(params,pagination);
        pro_produce.setPagedListInfo(pagination);
        result.put("pro_produce", pro_produce);
        
        return result;
    }
    /**
    选择记录表格
    */
    
    public Map selectRecordForm1() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_produce=mapper.t_produce(params);
        SQLMap t_produce_emt=t_produce.getExistfirst();
        result.put("t_produce", t_produce_emt);
        
        return result;
    }
    /**
    记录表格列表
    */
    
    public Map recordFormList() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_table=mapper.s_table(params);
        result.put("s_table", s_table);
        
        return result;
    }
    /**
    查看表格
    */
    
    public Map viowForm() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_record_table=mapper.s_record_table(params);
        SQLMap s_record_table_emt=s_record_table.getExistfirst();
        result.put("s_record_table", s_record_table_emt);
        
        return result;
    }
    /**
    检测流程图
    */
    
    public Map detectionFlow1() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object plan_name =mapper.plan_name(params);
        result.put("plan_name", plan_name);
        
        
        SQLList<SQLMap> flow_steps=mapper.flow_steps(params);
        result.put("flow_steps", flow_steps);
        
        
        SQLList<SQLMap> flow_skips=mapper.flow_skips(params);
        result.put("flow_skips", flow_skips);
        
        
        result.put("steps", flow_steps);
        
        
        result.put("skips", flow_skips);
        
        return result;
    }
    /**
    检测列表
    */
    
    public Map checklist1() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_step=mapper.s_step(params);
        result.put("s_step", s_step);
        
        return result;
    }
    /**
    工艺文件
    */
    
    public Map technologyDocuments() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        params.def("CMID9",-1);
        Object CMID9 =mapper.CMID9(params);
        result.put("CMID9", CMID9);
        
        
        params.def("CMID9",-1);
        SQLList<SQLMap> s_folder=mapper.s_folder(params);
        result.put("s_folder", s_folder);
        
        
        params.def("CMID9",-1);
        SQLList<SQLMap> s_file=mapper.s_file(params);
        result.put("s_file", s_file);
        
        
        params.def("CMID9",-1);
        SQLList<SQLMap> s_tree_menu=mapper.s_tree_menu(params);
        result.put("s_tree_menu", s_tree_menu);
        
        return result;
    }
    /**
    修改文件夹
    */
    
    public Map upTechnologyFolder() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_folders=mapper.s_folders(params);
        SQLMap s_folders_emt=s_folders.getExistfirst();
        result.put("s_folders", s_folders_emt);
        
        return result;
    }
    /**
    增加版本
    */
    
    public Map addVersionTechnology() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_file=mapper.s_file(params);
        SQLMap s_file_emt=s_file.getExistfirst();
        result.put("s_file", s_file_emt);
        
        return result;
    }
    /**
    文件版本
    */
    
    public Map fileVersionTechnology() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_file_version=mapper.s_file_version(params);
        result.put("s_file_version", s_file_version);
        
        return result;
    }
    /**
    选择检测开始项目
    */
    
    public Map selectDetectionStart() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object plan_name =mapper.plan_name(params);
        result.put("plan_name", plan_name);
        
        
        SQLList<SQLMap> s_phase=mapper.s_phase(params);
        result.put("s_phase", s_phase);
        
        return result;
    }
    /**
    修改阶段
    */
    
    public Map upStage1() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_phase=mapper.s_phase(params);
        result.put("s_phase", s_phase);
        
        return result;
    }
    /**
    选择项目列表
    */
    
    public Map testingItemsTech() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> tech_produce=mapper.tech_produce(params,pagination);
        tech_produce.setPagedListInfo(pagination);
        result.put("tech_produce", tech_produce);
        
        return result;
    }
    /**
    检测项目管理
    */
    
    public Map testingItemsMange() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object CMIDcategory_id =mapper.CMIDcategory_id(params);
        result.put("CMIDcategory_id", CMIDcategory_id);
        
        
        Object CMIDscheme_id =mapper.CMIDscheme_id(params);
        result.put("CMIDscheme_id", CMIDscheme_id);
        
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        
        SQLList<SQLMap> s_skip=mapper.s_skip(params);
        result.put("s_skip", s_skip);
        
        return result;
    }
    /**
    修改工序阶段
    */
    
    public Map modifyProcessStage() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_wrok=mapper.t_wrok(params);
        SQLMap t_wrok_emt=t_wrok.getExistfirst();
        result.put("t_wrok", t_wrok_emt);
        
        
        SQLList<SQLMap> s_phase=mapper.s_phase(params);
        result.put("s_phase", s_phase);
        
        return result;
    }
    /**
    增加下一步
    */
    
    public Map increaseStepTech() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_phase=mapper.s_phase(params);
        result.put("s_phase", s_phase);
        
        return result;
    }
    /**
    修改阶段
    */
    
    public Map upStage() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_phase=mapper.s_phase(params);
        result.put("s_phase", s_phase);
        
        return result;
    }
    /**
    检测项目增加下一步
    */
    
    public Map increaseItemStepTech() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> p_pro_produce=mapper.p_pro_produce(params,pagination);
        p_pro_produce.setPagedListInfo(pagination);
        result.put("p_pro_produce", p_pro_produce);
        
        return result;
    }
    /**
    检测项目关联下一步
    */
    
    public Map relevantNextItemStep() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_step=mapper.s_step(params);
        result.put("s_step", s_step);
        
        return result;
    }
    /**
    检验报告
    */
    
    public Map inspectionReport() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_step=mapper.s_step(params);
        result.put("s_step", s_step);
        
        return result;
    }
    /**
    选择记录表格
    */
    
    public Map selectRecordForm() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object CMIDprocess_id =mapper.CMIDprocess_id(params);
        result.put("CMIDprocess_id", CMIDprocess_id);
        
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        return result;
    }
    /**
    查看检测报告
    */
    
    public Map viewDetectionReport() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> l_record_work=mapper.l_record_work(params);
        result.put("l_record_work", l_record_work);
        
        
        result.put("record_string", buildTemplate(l_record_work));
        
        return result;
    }
    /**
    设置检测标准列表
    */
    
    public Map settingStandards() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_step=mapper.s_step(params);
        result.put("s_step", s_step);
        
        return result;
    }
    /**
    设置检测标准流程图
    */
    
    public Map settingChartStandard() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object plan_name =mapper.plan_name(params);
        result.put("plan_name", plan_name);
        
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        SQLList<SQLMap> skips=mapper.skips(params);
        result.put("skips", skips);
        
        return result;
    }
    /**
    检测项目列表
    */
    
    public Map testingItemsStandard() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pro_produce=mapper.s_pro_produce(params);
        result.put("s_pro_produce", s_pro_produce);
        
        return result;
    }
    /**
    设置检测项目流程图
    */
    
    public Map testingItemsChartStacndart() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object plan_name =mapper.plan_name(params);
        result.put("plan_name", plan_name);
        
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        SQLList<SQLMap> skips=mapper.skips(params);
        result.put("skips", skips);
        
        return result;
    }
    /**
    检测项目流程图
    */
    
    public Map testingItemsChart() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object plan_name =mapper.plan_name(params);
        result.put("plan_name", plan_name);
        
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        SQLList<SQLMap> skips=mapper.skips(params);
        result.put("skips", skips);
        
        return result;
    }
    /**
    检测项目列表
    */
    
    public Map testingItemsStandList() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pro_produce=mapper.s_pro_produce(params);
        result.put("s_pro_produce", s_pro_produce);
        
        return result;
    }
    /**
    检测项目管理
    */
    
    public Map testingItemsStandMang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object CMIDcategory_id =mapper.CMIDcategory_id(params);
        result.put("CMIDcategory_id", CMIDcategory_id);
        
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        
        SQLList<SQLMap> s_skip=mapper.s_skip(params);
        result.put("s_skip", s_skip);
        
        return result;
    }
    /**
    检测项目增加下一步
    */
    
    public Map addTestingItemsNext() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> pro_produce=mapper.pro_produce(params,pagination);
        pro_produce.setPagedListInfo(pagination);
        result.put("pro_produce", pro_produce);
        
        return result;
    }
    /**
    检测项目关联下一步
    */
    
    public Map relationTestingItemsNext() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_step=mapper.s_step(params);
        result.put("s_step", s_step);
        
        return result;
    }
    /**
    设置检测项目列表
    */
    
    public Map settingItemsStandLis() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_step=mapper.s_step(params);
        result.put("s_step", s_step);
        
        return result;
    }
    /**
    选择记录格式
    */
    
    public Map selectRecordFormatStand() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_table=mapper.s_table(params);
        result.put("s_table", s_table);
        
        return result;
    }
    /**
    查看格式明细
    */
    
    public Map viewFormatStand() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_record_table=mapper.s_record_table(params);
        SQLMap s_record_table_emt=s_record_table.getExistfirst();
        result.put("s_record_table", s_record_table_emt);
        
        return result;
    }
    /**
    查看检测模板
    */
    
    public Map viewDetectionTemplate() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> l_record_work=mapper.l_record_work(params);
        result.put("l_record_work", l_record_work);
        
        
        result.put("record_string", buildTemplate(l_record_work));
        
        return result;
    }
    /**
    检测标准流程图下一步
    */
    
    public Map testingStandardChar() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object CMIDcategory_id =mapper.CMIDcategory_id(params);
        result.put("CMIDcategory_id", CMIDcategory_id);
        
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        
        SQLList<SQLMap> s_skip=mapper.s_skip(params);
        result.put("s_skip", s_skip);
        
        return result;
    }
    /**
    检测标准增加下一步
    */
    
    public Map addTestingStandardNext() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        
        SQLList<SQLMap> p_tech=mapper.p_tech(params,pagination);
        p_tech.setPagedListInfo(pagination);
        result.put("p_tech", p_tech);
        
        return result;
    }
    /**
    检测标准关联下一步
    */
    
    public Map relationTestingStandardNext() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> p_step=mapper.p_step(params,pagination);
        p_step.setPagedListInfo(pagination);
        result.put("p_step", p_step);
        
        return result;
    }
    /**
    检测标准列表
    */
    
    public Map testingStandardList() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        
        SQLList<SQLMap> s_tech=mapper.s_tech(params,pagination);
        s_tech.setPagedListInfo(pagination);
        result.put("s_tech", s_tech);
        
        return result;
    }
    /**
    检测项目列表
    */
    
    public Map testingStandardItem() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pro_produce=mapper.s_pro_produce(params);
        result.put("s_pro_produce", s_pro_produce);
        
        return result;
    }
    /**
    设置检测项目流程图
    */
    
    public Map setTestingStandardChart() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object plan_name =mapper.plan_name(params);
        result.put("plan_name", plan_name);
        
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        SQLList<SQLMap> skips=mapper.skips(params);
        result.put("skips", skips);
        
        return result;
    }
    /**
    检测项目下一步
    */
    
    public Map testingItemNextChar() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        
        SQLList<SQLMap> s_skip=mapper.s_skip(params);
        result.put("s_skip", s_skip);
        
        return result;
    }
    /**
    项目流程图
    */
    
    public Map itemChart() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        SQLList<SQLMap> skips=mapper.skips(params);
        result.put("skips", skips);
        
        return result;
    }
    /**
    复制检测方案
    */
    
    public Map copyTestPlan() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_category=mapper.t_category(params);
        SQLMap t_category_emt=t_category.getExistfirst();
        result.put("t_category", t_category_emt);
        
        return result;
    }
    /**
    修改检测方案
    */
    
    public Map modifyTestPlan() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_category=mapper.t_category(params);
        SQLMap t_category_emt=t_category.getExistfirst();
        result.put("t_category", t_category_emt);
        
        return result;
    }
    /**
    生产流程图
    */
    
    public Map productFlow() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        SQLList<SQLMap> skips=mapper.skips(params);
        result.put("skips", skips);
        
        return result;
    }
    /**
    修改工艺
    */
    
    public Map upTechnology() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_tech=mapper.t_tech(params);
        SQLMap t_tech_emt=t_tech.getExistfirst();
        result.put("t_tech", t_tech_emt);
        
        return result;
    }
    /**
    生成生产流程
    */
    
    public Map productTechBuildFlow() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> pro_list=mapper.pro_list(params);
        result.put("pro_list", pro_list);
        
        
        
        
        
        
        
        
        
        return result;
    }
    /**
    设计流程
    */
    
    public Map productTechDesignFlow() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> tech_list=mapper.tech_list(params);
        result.put("tech_list", tech_list);
        
        return result;
    }
    /**
    增加检测标准
    */
    
    public Map technologyAdd() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_category=mapper.t_category(params);
        SQLMap t_category_emt=t_category.getExistfirst();
        result.put("t_category", t_category_emt);
        
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        return result;
    }
    /**
    产品部件列表
    */
    
    public Map productTechPartsList() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        params.def("category_id",-1);
        SQLList<SQLMap> produce=mapper.produce(params);
        produce.setSelectNone("produce备注");
        result.put("produce", produce);
        
        
        params.def("category_id",-1);
        SQLList<SQLMap> classid=mapper.classid(params);
        classid.setSelectNone("classid备注");
        result.put("classid", classid);
        
        
        params.def("category_id",-1);
        SQLList<SQLMap> cate=mapper.cate(params);
        SQLMap cate_emt=cate.getExistfirst();
        result.put("cate", cate_emt);
        
        
        
        
        
        
        SQLList<SQLMap> s_product=mapper.s_product(params);
        result.put("s_product", s_product);
        
        return result;
    }
    /**
    产品类别
    */
    
    public Map productClassTech() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        result.put("s_search", pagination.getSearchParas());
        
        
        SQLList<SQLMap> p_category=mapper.p_category(params,pagination);
        p_category.setPagedListInfo(pagination);
        result.put("p_category", p_category);
        
        return result;
    }
    /**
    修改产品类别
    */
    
    public Map upProductClassTec() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_procate=mapper.t_procate(params);
        SQLMap t_procate_emt=t_procate.getExistfirst();
        result.put("t_procate", t_procate_emt);
        
        return result;
    }
    /**
    明细
    */
    
    public Map technologyDet() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> l_tech=mapper.l_tech(params);
        SQLMap l_tech_emt=l_tech.getExistfirst();
        result.put("l_tech", l_tech_emt);
        
        return result;
    }
    /**
    工艺明细
    */
    
    public Map techProList() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> pro_list=mapper.pro_list(params);
        result.put("pro_list", pro_list);
        
        return result;
    }
    /**
    工序列表
    */
    
    public Map productTechProList() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> l_pro=mapper.l_pro(params);
        result.put("l_pro", l_pro);
        
        return result;
    }
    /**
    范围明细
    */
    
    public Map productTechDet() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> pro_list=mapper.pro_list(params);
        SQLMap pro_list_emt=pro_list.getExistfirst();
        result.put("pro_list", pro_list_emt);
        
        return result;
    }
    /**
    修改明细
    */
    
    public Map productTechUp() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> pro_list=mapper.pro_list(params);
        SQLMap pro_list_emt=pro_list.getExistfirst();
        result.put("pro_list", pro_list_emt);
        
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        return result;
    }
    /**
    适用产品
    */
    
    public Map productTechApplyPro() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_tech_produce=mapper.s_tech_produce(params,pagination);
        s_tech_produce.setPagedListInfo(pagination);
        result.put("s_tech_produce", s_tech_produce);
        
        return result;
    }
    /**
    选择适用产品
    */
    
    public Map applyProChoice() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        SQLList<SQLMap> s_type=mapper.s_type(params);
        result.put("s_type", s_type);
        
        
        params.def("CMID1",-1);
        SQLList<SQLMap> s_classid=mapper.s_classid(params);
        result.put("s_classid", s_classid);
        
        
        
        
        SQLList<SQLMap> apply_produce=mapper.apply_produce(params,pagination);
        apply_produce.setPagedListInfo(pagination);
        apply_produce.setSelectNone("produce备注");
        result.put("apply_produce", apply_produce);
        
        
        
        return result;
    }
    /**
    设定工位
    */
    
    public Map productTechSetStation() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_tech_process=mapper.s_tech_process(params);
        result.put("s_tech_process", s_tech_process);
        
        return result;
    }
    /**
    选择工位
    */
    
    public Map setStationChoice() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_layout_item=mapper.s_layout_item(params,pagination);
        s_layout_item.setPagedListInfo(pagination);
        result.put("s_layout_item", s_layout_item);
        
        return result;
    }
    /**
    工位明细
    */
    
    public Map setStationDet() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_plan_process_tech=mapper.s_plan_process_tech(params);
        result.put("s_plan_process_tech", s_plan_process_tech);
        
        return result;
    }
    /**
    工序工位
    */
    
    public Map setStationProcedure() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pro_layout=mapper.s_pro_layout(params);
        SQLMap s_pro_layout_emt=s_pro_layout.getExistfirst();
        result.put("s_pro_layout", s_pro_layout_emt);
        
        
        SQLList<SQLMap> s_pro_device=mapper.s_pro_device(params);
        result.put("s_pro_device", s_pro_device);
        
        
        SQLList<SQLMap> s_layout_device=mapper.s_layout_device(params);
        result.put("s_layout_device", s_layout_device);
        
        return result;
    }
    /**
    修改工作能力
    */
    
    public Map setStationAbility() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pro_layout=mapper.s_pro_layout(params);
        SQLMap s_pro_layout_emt=s_pro_layout.getExistfirst();
        result.put("s_pro_layout", s_pro_layout_emt);
        
        return result;
    }
    /**
    选择设备
    */
    
    public Map setStationDev() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> produce_info=mapper.produce_info(params,pagination);
        produce_info.setPagedListInfo(pagination);
        result.put("produce_info", produce_info);
        
        return result;
    }
    /**
    配置工序
    */
    
    public Map setProcedure() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> produce=mapper.produce(params);
        result.put("produce", produce);
        
        
        
        
        
        return result;
    }
    /**
    适用工序材料
    */
    
    public Map setProcedureMaterial() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_tech_process=mapper.s_tech_process(params);
        result.put("s_tech_process", s_tech_process);
        
        
        
        return result;
    }
    /**
    配置材料
    */
    
    public Map setMaterial() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_tech_process=mapper.s_tech_process(params);
        result.put("s_tech_process", s_tech_process);
        
        return result;
    }
    /**
    适用工序
    */
    
    public Map setMaterialProcedure() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> produce=mapper.produce(params);
        result.put("produce", produce);
        
        return result;
    }
    /**
    最小生产数
    */
    
    public Map setMaterialMini() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> produce=mapper.produce(params);
        result.put("produce", produce);
        
        
        
        
        
        return result;
    }
    /**
    配置明细
    */
    
    public Map setMaterialDet() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pro_stuff=mapper.s_pro_stuff(params);
        result.put("s_pro_stuff", s_pro_stuff);
        
        return result;
    }
    /**
    设置工艺间跳转
    */
    
    public Map productTechJump() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        SQLList<SQLMap> s_plan=mapper.s_plan(params);
        result.put("s_plan", s_plan);
        
        
        
        
        SQLList<SQLMap> s_next=mapper.s_next(params);
        result.put("s_next", s_next);
        
        return result;
    }
    /**
    流程图
    */
    
    public Map product() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        SQLList<SQLMap> skips=mapper.skips(params);
        result.put("skips", skips);
        
        return result;
    }
    /**
    检测项目
    */
    
    public Map techProcedure() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_tech_process=mapper.s_tech_process(params);
        result.put("s_tech_process", s_tech_process);
        
        return result;
    }
    /**
    选择工序
    */
    
    public Map procedureChoice() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        TreeBean tb;
        
        
        
        
        
        tb = createTreeBean("l_class_treecols");
        SQLList<SQLMap> l_class=mapper.l_class(params);
        l_class = l_class.buildTree(tb,tb.getPid());
        result.put("l_class", l_class);
        
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params,pagination);
        s_pro.setPagedListInfo(pagination);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    产品类别
    */
    
    public Map productClissRange() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> tech_pro=mapper.tech_pro(params);
        result.put("tech_pro", tech_pro);
        
        return result;
    }
    /**
    修改产品类别
    */
    
    public Map modifProductClissRange() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_procate=mapper.t_procate(params);
        SQLMap t_procate_emt=t_procate.getExistfirst();
        result.put("t_procate", t_procate_emt);
        
        return result;
    }
    /**
    所有的检测项目
    */
    
    public Map testingItemsRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        
        
        
        
        SQLList<SQLMap> s_produce=mapper.s_produce(params);
        result.put("s_produce", s_produce);
        
        
        SQLList<SQLMap> tech_pro=mapper.tech_pro(params);
        result.put("tech_pro", tech_pro);
        
        return result;
    }
    /**
    项目流程列表
    */
    
    public Map itemsListRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        
        
        SQLList<SQLMap> s_step=mapper.s_step(params);
        result.put("s_step", s_step);
        
        return result;
    }
    /**
    项目流流程图
    */
    
    public Map itemsChartRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object plan_name =mapper.plan_name(params);
        result.put("plan_name", plan_name);
        
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        
        
        SQLList<SQLMap> skips=mapper.skips(params);
        result.put("skips", skips);
        
        return result;
    }
    /**
    查看检测模板
    */
    
    public Map templateRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> l_record_work=mapper.l_record_work(params);
        result.put("l_record_work", l_record_work);
        
        
        result.put("record_string", buildTemplate(l_record_work));
        
        return result;
    }
    /**
    工序流列表
    */
    
    public Map processFlowRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        
        
        SQLList<SQLMap> s_step=mapper.s_step(params);
        result.put("s_step", s_step);
        
        return result;
    }
    /**
    流程图下一步
    */
    
    public Map processFlowNextRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        
        SQLList<SQLMap> s_skip=mapper.s_skip(params);
        result.put("s_skip", s_skip);
        
        return result;
    }
    /**
    流程图增加上一步
    */
    
    public Map flowChartUpRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_step=mapper.s_step(params);
        result.put("s_step", s_step);
        
        
        SQLList<SQLMap> s_test=mapper.s_test(params);
        result.put("s_test", s_test);
        
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params,pagination);
        s_pro.setPagedListInfo(pagination);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    修改操作人员
    */
    
    public Map modifyOperationRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        return result;
    }
    /**
    修改选择人员
    */
    
    public Map modifyPersonRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> person_info=mapper.person_info(params,pagination);
        person_info.setPagedListInfo(pagination);
        result.put("person_info", person_info);
        
        
        
        
        SQLList<SQLMap> parent=mapper.parent(params);
        SQLMap parent_emt=parent.getExistfirst();
        result.put("parent", parent_emt);
        
        return result;
    }
    /**
    流程图增加下一步
    */
    
    public Map addFlowChartNextRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        
        SQLList<SQLMap> s_test=mapper.s_test(params);
        result.put("s_test", s_test);
        
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params,pagination);
        s_pro.setPagedListInfo(pagination);
        result.put("s_pro", s_pro);
        
        
        SQLList<SQLMap> s_produce=mapper.s_produce(params);
        result.put("s_produce", s_produce);
        
        return result;
    }
    /**
    流程图关联下一步
    */
    
    public Map relationFlowChartRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        
        SQLList<SQLMap> s_test=mapper.s_test(params);
        result.put("s_test", s_test);
        
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params,pagination);
        s_pro.setPagedListInfo(pagination);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    单选增加开始工序
    */
    
    public Map oneStartProcessRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params,pagination);
        s_pro.setPagedListInfo(pagination);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    流程图选择工序
    */
    
    public Map flowChartChoicProcess() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        TreeBean tb;
        
        tb = createTreeBean("l_class_treecols");
        SQLList<SQLMap> l_class=mapper.l_class(params);
        l_class = l_class.buildTree(tb,tb.getPid());
        result.put("l_class", l_class);
        
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params,pagination);
        s_pro.setPagedListInfo(pagination);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    流程图选择开始工序
    */
    
    public Map flowChartOneProcess() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        TreeBean tb;
        
        tb = createTreeBean("l_class_treecols");
        SQLList<SQLMap> l_class=mapper.l_class(params);
        l_class = l_class.buildTree(tb,tb.getPid());
        result.put("l_class", l_class);
        
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params,pagination);
        s_pro.setPagedListInfo(pagination);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    流程图测试
    */
    
    public Map flowChartTest() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object CMIDplan_id =mapper.CMIDplan_id(params);
        result.put("CMIDplan_id", CMIDplan_id);
        
        
        Object plan_name =mapper.plan_name(params);
        result.put("plan_name", plan_name);
        
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        SQLList<SQLMap> phases=mapper.phases(params);
        result.put("phases", phases);
        
        
        SQLList<SQLMap> skips=mapper.skips(params);
        result.put("skips", skips);
        
        return result;
    }
    /**
    设置操作步骤
    */
    
    public Map settingStepRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> step=mapper.step(params);
        result.put("step", step);
        
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        
        
        
        SQLList<SQLMap> s_step=mapper.s_step(params);
        result.put("s_step", s_step);
        
        
        
        return result;
    }
    /**
    管理操作步骤
    */
    
    public Map manageStepRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> step=mapper.step(params);
        result.put("step", step);
        
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        
        SQLList<SQLMap> s_step=mapper.s_step(params);
        result.put("s_step", s_step);
        
        
        SQLList<SQLMap> s_skip=mapper.s_skip(params);
        result.put("s_skip", s_skip);
        
        return result;
    }
    /**
    并行工序增加
    */
    
    public Map addParalleProcess() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_hpase=mapper.s_hpase(params);
        result.put("s_hpase", s_hpase);
        
        return result;
    }
    /**
    工序增加
    */
    
    public Map addProcessRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params,pagination);
        s_pro.setPagedListInfo(pagination);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    阶段工序增加
    */
    
    public Map addStageProcessRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> s_step=mapper.s_step(params);
        result.put("s_step", s_step);
        
        return result;
    }
    /**
    选择工序
    */
    
    public Map choiceProcessRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        TreeBean tb;
        
        tb = createTreeBean("l_class_treecols");
        SQLList<SQLMap> l_class=mapper.l_class(params);
        l_class = l_class.buildTree(tb,tb.getPid());
        result.put("l_class", l_class);
        
        
        SQLList<SQLMap> s_pro=mapper.s_pro(params,pagination);
        s_pro.setPagedListInfo(pagination);
        result.put("s_pro", s_pro);
        
        return result;
    }
    /**
    设置操作
    */
    
    public Map setSetingRang() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> t_step=mapper.t_step(params);
        SQLMap t_step_emt=t_step.getExistfirst();
        result.put("t_step", t_step_emt);
        
        return result;
    }
    /**
    设置选择人员
    */
    
    public Map setChoicePerson() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> person_info=mapper.person_info(params,pagination);
        person_info.setPagedListInfo(pagination);
        result.put("person_info", person_info);
        
        
        
        
        SQLList<SQLMap> parent=mapper.parent(params);
        SQLMap parent_emt=parent.getExistfirst();
        result.put("parent", parent_emt);
        
        return result;
    }
    /**
    工序流流程图
    */
    
    public Map processChar() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        SQLList<SQLMap> steps=mapper.steps(params);
        result.put("steps", steps);
        
        
        Object plan_name =mapper.plan_name(params);
        result.put("plan_name", plan_name);
        
        
        
        
        SQLList<SQLMap> skips=mapper.skips(params);
        result.put("skips", skips);
        
        return result;
    }
    public void onvalidate(){
    }
    /**
    */
    
    public Map d_category() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        mapper.d_category(params);
        
        return result;
    }
    /**
    生产步骤表修改
    */
    
    public Map productTechStepSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("action_step_skip")){
            params=new SQLParam(request,emt.getMap());
            mapper.i_action_step_skip(params);
        }
        
        return result;
    }
    /**
    配置阶段修改
    */
    
    public Map productTechStageSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("action_step_skip")){
            params=new SQLParam(request,emt.getMap());
            mapper.u_action_step_skip(params);
        }
        
        return result;
    }
    /**
    */
    
    public Map d_phase() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_phase(params);
        
        return result;
    }
    /**
    检测项目流程图修改
    */
    
    public Map projectFlowChartSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        TreeTableHelper.parseFlowJson(context,request.getParameter("pathInfo"));
        
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.projectFlowChartSubmit(params);
        }
        
        return result;
    }
    /**
    */
    
    public Map onInsertFile() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object name =
        mapper.name(params);
        result.put("name", name);
        
        
        
        return result;
    }
    /**
    流程图下一步修改
    */
    
    public Map chartNextStepSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMIDnext_stepid = mapper.CMIDnext_stepid(params);
        result.put("CMIDnext_stepid", CMIDnext_stepid);
        
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    */
    
    public Map d_skip_test() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_skip_test(params);
        
        return result;
    }
    /**
    */
    
    public Map d_skip() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_skip(params);
        
        return result;
    }
    /**
    */
    
    public Map d_step() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_step(params);
        
        return result;
    }
    /**
    关联下一步修改
    */
    
    public Map relevantNextStep1Submit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    */
    
    public Map d_scheme() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_scheme(params);
        
        return result;
    }
    /**
    增加检测方案修改
    */
    
    public Map addTestPlanSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    修改检测方案修改
    */
    
    public Map upTestPlan1Submit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    */
    
    public Map enable() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.enable(params);
        
        return result;
    }
    /**
    */
    
    public Map disable() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.disable(params);
        
        return result;
    }
    /**
    */
    
    public Map d_tech() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_tech(params);
        
        return result;
    }
    /**
    选择适用产品修改
    */
    
    public Map choiceProductPlanSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("tech_produce")){
            params=new SQLParam(request,emt.getMap());
            mapper.i_tech_produce(params);
        }
        
        return result;
    }
    /**
    检测方案修改修改
    */
    
    public Map upTestPlanSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.upTestPlanSubmit(params);
        
        return result;
    }
    /**
    引用检测标准修改
    */
    
    public Map referenceTestCriteriaSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMIDtech_id = mapper.CMIDtech_id(params);
        result.put("CMIDtech_id", CMIDtech_id);
        
        
        mapper.referenceTestCriteriaSubmit(params);
        
        return result;
    }
    /**
    修改检测标准修改
    */
    
    public Map upTestingCriteriaSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMID = mapper.CMID(params);
        result.put("CMID", CMID);
        
        return result;
    }
    /**
    */
    
    public Map d_tech_process() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_tech_process(params);
        
        return result;
    }
    /**
    选择工序修改
    */
    
    public Map selectionProcessPlanSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.selectionProcessPlanSubmit(params);
        }
        
        return result;
    }
    /**
    选择记录表格修改
    */
    
    public Map selectRecordForm1Submit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.selectRecordForm1Submit(params);
        
        return result;
    }
    /**
    检测流程图修改
    */
    
    public Map detectionFlow1Submit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        TreeTableHelper.parseFlowJson(context,request.getParameter("pathInfo"));
        
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.detectionFlow1Submit(params);
        }
        
        
        result.put("msg", "保存成功");
        
        return result;
    }
    /**
    */
    
    public Map d_plan_step() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_plan_step(params);
        
        return result;
    }
    /**
    新文件夹修改
    */
    
    public Map technologyNewFolderSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        params.def("CMIDcategory_id",null);
        params.def("CMID9",-1);
        int i_folder = mapper.i_folder(params);
        result.put("i_folder", i_folder);
        
        return result;
    }
    /**
    修改文件夹修改
    */
    
    public Map upTechnologyFolderSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_folder = mapper.i_folder(params);
        result.put("i_folder", i_folder);
        
        return result;
    }
    /**
    */
    
    public Map d_files_version() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_files_version(params);
        
        return result;
    }
    /**
    选择检测开始项目修改
    */
    
    public Map selectDetectionStartSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        int step_id = mapper.step_id(params);
        result.put("step_id", step_id);
        
        return result;
    }
    /**
    增加阶段修改
    */
    
    public Map increasingStage1Submit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_phase = mapper.i_phase(params);
        result.put("i_phase", i_phase);
        
        return result;
    }
    /**
    选择项目列表修改
    */
    
    public Map testingItemsTechSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        int step_id = mapper.step_id(params);
        result.put("step_id", step_id);
        
        return result;
    }
    /**
    修改工序阶段修改
    */
    
    public Map modifyProcessStageSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.modifyProcessStageSubmit(params);
        
        return result;
    }
    /**
    增加下一步修改
    */
    
    public Map increaseStepTechSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int stepid = mapper.stepid(params);
        result.put("stepid", stepid);
        
        
        int i_skip_id = mapper.i_skip_id(params);
        result.put("i_skip_id", i_skip_id);
        
        return result;
    }
    /**
    增加阶段修改
    */
    
    public Map increasingStageSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_phase = mapper.i_phase(params);
        result.put("i_phase", i_phase);
        
        return result;
    }
    /**
    检测项目增加下一步修改
    */
    
    public Map increaseItemStepTechSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            if(SQL.isNotNull(params.get("tech_process_id")))
            mapper.stepid(params);
        }
        
        return result;
    }
    /**
    关联下一步修改
    */
    
    public Map relevantNextStepSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.relevantNextStepSubmit(params);
        
        return result;
    }
    /**
    检测项目关联下一步修改
    */
    
    public Map relevantNextItemStepSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        mapper.relevantNextItemStepSubmit(params);
        
        return result;
    }
    /**
    选择记录表格修改
    */
    
    public Map selectRecordFormSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.selectRecordFormSubmit(params);
        
        return result;
    }
    /**
    设置检测标准流程图修改
    */
    
    public Map settingChartStandardSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        TreeTableHelper.parseFlowJson(context,request.getParameter("pathInfo"));
        
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.settingChartStandardSubmit(params);
        }
        
        return result;
    }
    /**
    检测项目流程图修改
    */
    
    public Map testingItemsChartSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        TreeTableHelper.parseFlowJson(context,request.getParameter("pathInfo"));
        
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.testingItemsChartSubmit(params);
        }
        
        return result;
    }
    /**
    选择检测开始项目修改
    */
    
    public Map chioceTestingItemsSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int step_id = mapper.step_id(params);
        result.put("step_id", step_id);
        
        return result;
    }
    /**
    检测项目增加下一步修改
    */
    
    public Map addTestingItemsNextSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int step_id = mapper.step_id(params);
        result.put("step_id", step_id);
        
        
        int i_skip_id = mapper.i_skip_id(params);
        result.put("i_skip_id", i_skip_id);
        
        return result;
    }
    /**
    检测项目关联下一步修改
    */
    
    public Map relationTestingItemsNextSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.relationTestingItemsNextSubmit(params);
        
        return result;
    }
    /**
    选择记录格式修改
    */
    
    public Map selectRecordFormatStandSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.selectRecordFormatStandSubmit(params);
        
        return result;
    }
    /**
    检测标准增加下一步修改
    */
    
    public Map addTestingStandardNextSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMIDnext_stepid = mapper.CMIDnext_stepid(params);
        result.put("CMIDnext_stepid", CMIDnext_stepid);
        
        
        int i_skip = mapper.i_skip(params);
        result.put("i_skip", i_skip);
        
        
        mapper.addTestingStandardNextSubmit(params);
        
        return result;
    }
    /**
    检测标准关联下一步修改
    */
    
    public Map relationTestingStandardNextSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_skip = mapper.i_skip(params);
        result.put("i_skip", i_skip);
        
        return result;
    }
    /**
    选择开始检测标准修改
    */
    
    public Map choiceTestingStandardSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int step_id = mapper.step_id(params);
        result.put("step_id", step_id);
        
        
        mapper.choiceTestingStandardSubmit(params);
        
        
        
        return result;
    }
    /**
    设置检测项目流程图修改
    */
    
    public Map setTestingStandardChartSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        TreeTableHelper.parseFlowJson(context,request.getParameter("pathInfo"));
        
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.setTestingStandardChartSubmit(params);
        }
        
        return result;
    }
    /**
    检测项目下一步修改
    */
    
    public Map testingItemNextCharSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMIDnext_stepid = mapper.CMIDnext_stepid(params);
        result.put("CMIDnext_stepid", CMIDnext_stepid);
        
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    项目流程图修改
    */
    
    public Map itemChartSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        TreeTableHelper.parseFlowJson(context,request.getParameter("pathInfo"));
        
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.itemChartSubmit(params);
        }
        
        return result;
    }
    /**
    复制检测方案修改
    */
    
    public Map copyTestPlanSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int category_id = mapper.category_id(params);
        result.put("category_id", category_id);
        
        
        mapper.copyTestPlanSubmit(params);
        
        return result;
    }
    /**
    */
    
    public Map i_cate() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i_catege = mapper.i_catege(params);
        result.put("i_catege", i_catege);
        
        return result;
    }
    /**
    修改检测方案修改
    */
    
    public Map modifyTestPlanSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.modifyTestPlanSubmit(params);
        
        return result;
    }
    /**
    修改工艺修改
    */
    
    public Map upTechnologySubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.upTechnologySubmit(params);
        
        return result;
    }
    /**
    生成生产流程修改
    */
    
    public Map productTechBuildFlowSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMID2 = mapper.CMID2(params);
        result.put("CMID2", CMID2);
        
        
        int CMID3 = mapper.CMID3(params);
        result.put("CMID3", CMID3);
        
        
        params.def("CMID3",-1);
        int i_action_step = mapper.i_action_step(params);
        result.put("i_action_step", i_action_step);
        
        return result;
    }
    /**
    增加检测标准修改
    */
    
    public Map technologyAddSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        int CMID = mapper.CMID(params);
        result.put("CMID", CMID);
        
        
        mapper.technologyAddSubmit(params);
        
        return result;
    }
    /**
    */
    
    public Map d_pro() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_pro(params);
        
        return result;
    }
    /**
    增加产品类别修改
    */
    
    public Map addProductClassTecSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    修改产品类别修改
    */
    
    public Map upProductClassTecSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    修改修改
    */
    
    public Map technologyUpSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMID = mapper.CMID(params);
        result.put("CMID", CMID);
        
        return result;
    }
    /**
    增加工序修改
    */
    
    public Map productTechProAddSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMID1 = mapper.CMID1(params);
        result.put("CMID1", CMID1);
        
        return result;
    }
    /**
    修改明细修改
    */
    
    public Map productTechUpSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.productTechUpSubmit(params);
        
        return result;
    }
    /**
    选择适用产品修改
    */
    
    public Map applyProChoiceSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("tech_produce")){
            params=new SQLParam(request,emt.getMap());
            mapper.i_tech_produce(params);
        }
        
        return result;
    }
    /**
    设定工位修改
    */
    
    public Map productTechSetStationSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.productTechSetStationSubmit(params);
        
        
        for (SQLMap emt:hqlBean.getTableElements("plan_process_tech")){
            params=new SQLParam(request,emt.getMap());
            mapper.i_plan_process_tech(params);
        }
        
        return result;
    }
    /**
    */
    
    public Map d_pro_device() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_pro_device(params);
        
        return result;
    }
    /**
    修改工作能力修改
    */
    
    public Map setStationAbilitySubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        Object pro_layout_cnt =
        mapper.pro_layout_cnt(params);
        result.put("pro_layout_cnt", pro_layout_cnt);
        
        
        mapper.setStationAbilitySubmit(params);
        
        return result;
    }
    /**
    选择设备修改
    */
    
    public Map setStationDevSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("pro_device")){
            params=new SQLParam(request,emt.getMap());
            mapper.i_device(params);
        }
        
        return result;
    }
    /**
    配置工序修改
    */
    
    public Map setProcedureSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("pro_stuff")){
            params=new SQLParam(request,emt.getMap());
            mapper.i_pro_stuff(params);
        }
        
        return result;
    }
    /**
    配置材料修改
    */
    
    public Map setMaterialSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("pro_stuff")){
            params=new SQLParam(request,emt.getMap());
            mapper.i_pro_stuff(params);
        }
        
        return result;
    }
    /**
    适用工序修改
    */
    
    public Map setMaterialProcedureSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("pro_stuff")){
            params=new SQLParam(request,emt.getMap());
            mapper.setMaterialProcedureSubmit(params);
        }
        
        return result;
    }
    /**
    */
    
    public Map d_pro_stuff() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_pro_stuff(params);
        
        return result;
    }
    /**
    设置工艺间跳转修改
    */
    
    public Map productTechJumpSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("action_step_skip")){
            params=new SQLParam(request,emt.getMap());
            mapper.u_action_step_skip(params);
        }
        
        return result;
    }
    /**
    */
    
    public Map d_process_id() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.d_process_id(params);
        
        return result;
    }
    /**
    选择工序修改
    */
    
    public Map procedureChoiceSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("tech_process")){
            params=new SQLParam(request,emt.getMap());
            mapper.i_tech_process(params);
        }
        
        return result;
    }
    /**
    增加产品类别修改
    */
    
    public Map addProductClissRangeSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    修改产品类别修改
    */
    
    public Map modifProductClissRangeSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    项目流流程图修改
    */
    
    public Map itemsChartRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        TreeTableHelper.parseFlowJson(context,request.getParameter("pathInfo"));
        
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.itemsChartRangSubmit(params);
        }
        
        return result;
    }
    /**
    流程图下一步修改
    */
    
    public Map processFlowNextRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMIDnext_stepid = mapper.CMIDnext_stepid(params);
        result.put("CMIDnext_stepid", CMIDnext_stepid);
        
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    流程图增加上一步修改
    */
    
    public Map flowChartUpRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    修改操作人员修改
    */
    
    public Map modifyOperationRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.modifyOperationRangSubmit(params);
        
        return result;
    }
    /**
    流程图增加下一步修改
    */
    
    public Map addFlowChartNextRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int CMIDnext_stepid = mapper.CMIDnext_stepid(params);
        result.put("CMIDnext_stepid", CMIDnext_stepid);
        
        
        mapper.addFlowChartNextRangSubmit(params);
        
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    流程图关联下一步修改
    */
    
    public Map relationFlowChartRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    单选增加开始工序修改
    */
    
    public Map oneStartProcessRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int step_id = mapper.step_id(params);
        result.put("step_id", step_id);
        
        
        mapper.oneStartProcessRangSubmit(params);
        
        return result;
    }
    /**
    */
    
    public Map i_step() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int step_id = mapper.step_id(params);
        result.put("step_id", step_id);
        
        
        mapper.i_step(params);
        
        return result;
    }
    /**
    工序阶段增加修改
    */
    
    public Map addStagesRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    设置操作步骤修改
    */
    
    public Map settingStepRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.settingStepRangSubmit(params);
        }
        
        return result;
    }
    /**
    管理操作步骤修改
    */
    
    public Map manageStepRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.manageStepRangSubmit(params);
        }
        
        return result;
    }
    /**
    并行工序增加修改
    */
    
    public Map addParalleProcessSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    工序增加修改
    */
    
    public Map addProcessRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.i(params);
        }
        
        return result;
    }
    /**
    阶段工序增加修改
    */
    
    public Map addStageProcessRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        int i = mapper.i(params);
        result.put("i", i);
        
        return result;
    }
    /**
    设置操作修改
    */
    
    public Map setSetingRangSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        mapper.setSetingRangSubmit(params);
        
        return result;
    }
    /**
    工序流流程图修改
    */
    
    public Map processCharSubmit() {
        
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        TreeTableHelper.parseFlowJson(context,request.getParameter("pathInfo"));
        
        
        for (SQLMap emt:hqlBean.getTableElements("")){
            params=new SQLParam(request,emt.getMap());
            mapper.processCharSubmit(params);
        }
        
        return result;
    }
    public String ajaxComplete(){
        String sql="";
        String pagesql="";
        Map result=new HashMap();
        SQLParam params=new SQLParam(request,result);
        
        if(request.getParameter("cfield_name").equals("s_pro_category")){
            SQLList<SQLMap> s_pro_category=mapper.s_pro_category(params);
            request.setAttribute("s_pro_category", s_pro_category);
        }
        
        
        if(request.getParameter("cfield_name").equals("s_category")){
            SQLList<SQLMap> s_category=mapper.s_category(params);
            request.setAttribute("s_category", s_category);
        }
        
        return AJAXCOMPLETE;
    }
}